<?php  // $Id: textlib.class.php,v 1.25 2007/10/10 05:25:15 nicolasconnault Exp $

///////////////////////////////////////////////////////////////////////////
//																	   //
// NOTICE OF COPYRIGHT												   //
//																	   //
// Moodle - Modular Object-Oriented Dynamic Learning Environment		 //
//		  http://moodle.com											//
//																	   //
// Copyright (C) 1999 onwards Martin Dougiamas		http://dougiamas.com  //
//		   (C) 2001-3001 Eloy Lafuente (stronk7) http://contiento.com  //
//																	   //
// This program is free software; you can redistribute it and/or modify  //
// it under the terms of the GNU General Public License as published by  //
// the Free Software Foundation; either version 2 of the License, or	 //
// (at your option) any later version.								   //
//																	   //
// This program is distributed in the hope that it will be useful,	   //
// but WITHOUT ANY WARRANTY; without even the implied warranty of		//
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the		 //
// GNU General Public License for more details:						  //
//																	   //
//		  http://www.gnu.org/copyleft/gpl.html						 //
//																	   //
///////////////////////////////////////////////////////////////////////////

/// Required files
	require_once($CFG->libdir.'/typo3/class.t3lib_cs.php');
	require_once($CFG->libdir.'/typo3/class.t3lib_div.php');

/// If ICONV is available, lets Typo3 library use it for convert
	if (extension_loaded('iconv')) {
		$GLOBALS['TYPO3_CONF_VARS']['SYS']['t3lib_cs_convMethod'] = 'iconv';
	/// Else if mbstring is available, lets Typo3 library use it
	} else if (extension_loaded('mbstring')) {
		$GLOBALS['TYPO3_CONF_VARS']['SYS']['t3lib_cs_convMethod'] = 'mbstring';
	/// Else if recode is available, lets Typo3 library use it
	} else if (extension_loaded('recode')) {
		$GLOBALS['TYPO3_CONF_VARS']['SYS']['t3lib_cs_convMethod'] = 'recode';
	} else {
		$GLOBALS['TYPO3_CONF_VARS']['SYS']['t3lib_cs_convMethod'] = '';
	}

/// If mbstring is available, lets Typo3 library use it for functions
	if (extension_loaded('mbstring')) {
		$GLOBALS['TYPO3_CONF_VARS']['SYS']['t3lib_cs_utils'] = 'mbstring';
	} else {
		$GLOBALS['TYPO3_CONF_VARS']['SYS']['t3lib_cs_utils'] = '';
	}

/// And this directory must exist to allow Typo to cache conversion
/// tables when using internal functions
	make_upload_directory('temp/typo3temp/cs');

/// Default mask for Typo
	$GLOBALS['TYPO3_CONF_VARS']['BE']['fileCreateMask'] = $CFG->directorypermissions;

/// This full path constants must be defined too, transforming backslashes
/// to forward slashed beacuse Typo3 requires it.
	define ('PATH_t3lib', str_replace('\\','/',$CFG->libdir.'/typo3/'));
	define ('PATH_typo3', str_replace('\\','/',$CFG->libdir.'/typo3/'));
	define ('PATH_site', str_replace('\\','/',$CFG->dataroot.'/temp/'));
	define ('TYPO3_OS', stristr(PHP_OS,'win')&&!stristr(PHP_OS,'darwin')?'WIN':'');


/// As we implement the singleton pattern to use this class (only one instance
/// is shared globally), we need this helper function

/// IMPORTANT Note: Typo3 libraries always expect lowercase charsets to use 100%
///				 its capabilities so, don't forget to make the conversion
///				 from every wrapper function!

function textlib_get_instance() {
	static $instance;
	if (!is_object($instance)) {
		$instance = new textlib();
	}
	return $instance;
}

/**
 * This class is used to manipulate strings under Moodle 1.6 an later. As
 * utf-8 text become mandatory a pool of safe functions under this encoding
 * become necessary. The name of the methods is exactly the
 * same than their PHP originals.
 *
 * A big part of this class acts as a wrapper over the Typo3 charset library,
 * really a cool group of utilities to handle texts and encoding conversion.
 *
 * Take a look to its own copyright and license details.
 */
class textlib {

	var $typo3cs;

	/**
	 * Standard constructor of the class. All it does is to instantiate
	 * a new t3lib_cs object to have all their functions ready.
	 *
	 * Instead of istantiating a lot of objects of this class everytime
	 * some of their functions is going to be used, you can invoke the:
	 * textlib_get_instance() function, avoiding the creation of them
	 * (following the singleton pattern)
	 */
	function textlib() {
		/// Instantiate a conversor object some of the methods in typo3
		/// reference to $this and cannot be executed in a static context
		$this->typo3cs = new t3lib_cs();
	}

	/**
	 * Converts the text between different encodings. It will use iconv, mbstring
	 * or internal (typo3) methods to try such conversion. Returns false if fails.
	 */
	function convert($text, $fromCS, $toCS='utf-8') {
	/// Normalize charsets
		$fromCS = $this->typo3cs->parse_charset($fromCS);
		$toCS   = $this->typo3cs->parse_charset($toCS);
	/// Avoid some notices from Typo3 code
		$oldlevel = error_reporting(E_PARSE);
	/// Call Typo3 conv() function. It will do all the work
		$result = $this->typo3cs->conv($text, $fromCS, $toCS);
	/// Restore original debug level
		error_reporting($oldlevel);
		return $result;
	}

	/**
	 * Multibyte safe substr() function, uses mbstring if available.
	 */
	function substr($text, $start, $len=null, $charset='utf-8') {
	/// Normalize charset
		$charset = $this->typo3cs->parse_charset($charset);
	/// Avoid some notices from Typo3 code
		$oldlevel = error_reporting(E_PARSE);
	/// Call Typo3 substr() function. It will do all the work
		$result = $this->typo3cs->substr($charset,$text,$start,$len);
	/// Restore original debug level
		error_reporting($oldlevel);
		return $result;
	}

	/**
	 * Multibyte safe strlen() function, uses mbstring if available.
	 */
	function strlen($text, $charset='utf-8') {
	/// Normalize charset
		$charset = $this->typo3cs->parse_charset($charset);
	/// Avoid some notices from Typo3 code
		$oldlevel = error_reporting(E_PARSE);
	/// Call Typo3 strlen() function. It will do all the work
		$result = $this->typo3cs->strlen($charset,$text);
	/// Restore original debug level
		error_reporting($oldlevel);
		return $result;
	}

	/**
	 * Multibyte safe strtolower() function, uses mbstring if available.
	 */
	function strtolower($text, $charset='utf-8') {
	/// Normalize charset
		$charset = $this->typo3cs->parse_charset($charset);
	/// Avoid some notices from Typo3 code
		$oldlevel = error_reporting(E_PARSE);
	/// Call Typo3 conv_case() function. It will do all the work
		$result = $this->typo3cs->conv_case($charset,$text,'toLower');
	/// Restore original debug level
		error_reporting($oldlevel);
		return $result;
	}

	/**
	 * Multibyte safe strtoupper() function, uses mbstring if available.
	 */
	function strtoupper($text, $charset='utf-8') {
	/// Normalize charset
		$charset = $this->typo3cs->parse_charset($charset);
	/// Avoid some notices from Typo3 code
		$oldlevel = error_reporting(E_PARSE);
	/// Call Typo3 conv_case() function. It will do all the work
		$result = $this->typo3cs->conv_case($charset,$text,'toUpper');
	/// Restore original debug level
		error_reporting($oldlevel);
		return $result;
	}

	/**
	 * UTF-8 ONLY safe strpos() function, uses mbstring if available.
	 */
	function strpos($haystack,$needle,$offset=0) {
	/// Call Typo3 utf8_strpos() function. It will do all the work
		return $this->typo3cs->utf8_strpos($haystack,$needle,$offset);
	}

	/**
	 * UTF-8 ONLY safe strrpos() function, uses mbstring if available.
	 */
	function strrpos($haystack,$needle) {
	/// Call Typo3 utf8_strrpos() function. It will do all the work
		return $this->typo3cs->utf8_strrpos($haystack,$needle);
	}

	/**
	 * Try to convert upper unicode characters to plain ascii,
	 * the returned string may cantain unconverted unicode characters.
	 */
	function specialtoascii($text,$charset='utf-8') {
	/// Normalize charset
		$charset = $this->typo3cs->parse_charset($charset);
	/// Avoid some notices from Typo3 code
		$oldlevel = error_reporting(E_PARSE);
		$result = $this->typo3cs->specCharsToASCII($charset,$text);
	/// Restore original debug level
		error_reporting($oldlevel);
		return $result;
	}

	/**
	 * Generate a correct base64 encoded header to be used in MIME mail messages.
	 * This function seems to be 100% compliant with RFC1342. Credits go to:
	 * paravoid (http://www.php.net/manual/en/function.mb-encode-mimeheader.php#60283).
	 */
	function encode_mimeheader($text, $charset='utf-8') {
		if (empty($text)) {
			return (string)$text;
		}
	/// Normalize charset
		$charset = $this->typo3cs->parse_charset($charset);
	/// If the text is pure ASCII, we don't need to encode it
		if ($this->convert($text, $charset, 'ascii') == $text) {
			return $text;
		}
	/// Although RFC says that line feed should be \r\n, it seems that
	/// some mailers double convert \r, so we are going to use \n alone
		$linefeed="\n";
	/// Define start and end of every chunk
		$start = "=?$charset?B?";
		$end = "?=";
	/// Acumulate results
		$encoded = '';
	/// Max line length is 75 (including start and end)
		$length = 75 - strlen($start) - strlen($end);
	/// Multi-byte ratio
		$multilength = $this->strlen($text, $charset);
	/// Detect if strlen and friends supported
		if ($multilength === false) {
			if ($charset == 'GB18030' or $charset == 'gb18030') {
				while (strlen($text)) {
					// try to encode first 22 chars - we expect most chars are two bytes long
					if (preg_match('/^(([\x00-\x7f])|([\x81-\xfe][\x40-\x7e])|([\x81-\xfe][\x80-\xfe])|([\x81-\xfe][\x30-\x39]..)){1,22}/m', $text, $matches)) {
						$chunk = $matches[0];
						$encchunk = base64_encode($chunk);
						if (strlen($encchunk) > $length) {
							// find first 11 chars - each char in 4 bytes - worst case scenario
							preg_match('/^(([\x00-\x7f])|([\x81-\xfe][\x40-\x7e])|([\x81-\xfe][\x80-\xfe])|([\x81-\xfe][\x30-\x39]..)){1,11}/m', $text, $matches);
							$chunk = $matches[0];
							$encchunk = base64_encode($chunk);
						}
						$text = substr($text, strlen($chunk));
						$encoded .= ' '.$start.$encchunk.$end.$linefeed;
					} else {
						break;
					}
				}
				$encoded = trim($encoded);
				return $encoded;
			} else {
				return false;
			}
		}
		$ratio = $multilength / strlen($text);
	/// Base64 ratio
		$magic = $avglength = floor(3 * $length * $ratio / 4);
	/// basic infinite loop protection
		$maxiterations = strlen($text)*2;
		$iteration = 0;
	/// Iterate over the string in magic chunks
		for ($i=0; $i <= $multilength; $i+=$magic) {
			if ($iteration++ > $maxiterations) {
				return false; // probably infinite loop
			}
			$magic = $avglength;
			$offset = 0;
		/// Ensure the chunk fits in length, reduding magic if necessary
			do {
				$magic -= $offset;
				$chunk = $this->substr($text, $i, $magic, $charset);
				$chunk = base64_encode($chunk);
				$offset++;
			} while (strlen($chunk) > $length);
		/// This chunk doen't break any multi-byte char. Use it.
			if ($chunk)
				$encoded .= ' '.$start.$chunk.$end.$linefeed;
		}
	/// Strip the first space and the last linefeed
		$encoded = substr($encoded, 1, -strlen($linefeed));

		return $encoded;
	}

	/**
	 * Converts all the numeric entities &#nnnn; or &#xnnn; to UTF-8
	 * Original from laurynas dot butkus at gmail at:
	 * http://php.net/manual/en/function.html-entity-decode.php#75153
	 * with some custom mods to provide more functionality
	 *
	 * @param	string	$str	  input string
	 * @param	boolean   $htmlent  convert also html entities (defaults to true)
	 *
	 * NOTE: we could have used typo3 entities_to_utf8() here
	 *	   but the direct alternative used runs 400% quicker
	 *	   and uses 0.5Mb less memory, so, let's use it
	 *	   (tested agains 10^6 conversions)
	 */
	function entities_to_utf8($str, $htmlent=true) {

		static $trans_tbl; /// Going to use static translit table

	/// Replace numeric entities
		$result = preg_replace('~&#x([0-9a-f]+);~ei', 'textlib::code2utf8(hexdec("\\1"))', $str);
		$result = preg_replace('~&#([0-9]+);~e', 'textlib::code2utf8(\\1)', $result);

	/// Replace literal entities (if desired)
		if ($htmlent) {
		/// Generate/create $trans_tbl
			if (!isset($trans_tbl)) {
				$trans_tbl = array();
				foreach (get_html_translation_table(HTML_ENTITIES) as $val=>$key) {
					$trans_tbl[$key] = utf8_encode($val);
				}
			}
			$result = strtr($result, $trans_tbl);
		}
	/// Return utf8-ised string
		return $result;
	}

	/**
	 * Converts all Unicode chars > 127 to numeric entities &#nnnn; or &#xnnn;.
	 *
	 * @param	string		 input string
	 * @param	boolean		output decadic only number entities
	 * @param	boolean		remove all nonumeric entities
	 * @return   string		 converted string
	 */
	function utf8_to_entities($str, $dec=false, $nonnum=false) {
	/// Avoid some notices from Typo3 code
		$oldlevel = error_reporting(E_PARSE);
		if ($nonnum) {
			$str = $this->typo3cs->entities_to_utf8($str, true);
		}
		$result = $this->typo3cs->utf8_to_entities($str);
		if ($dec) {
			$result = preg_replace('/&#x([0-9a-f]+);/ie', "'&#'.hexdec('$1').';'", $result);
		}
	/// Restore original debug level
		error_reporting($oldlevel);
		return $result;
	}

	/**
	 * Removes the BOM from unicode string - see http://unicode.org/faq/utf_bom.html
	 */
	function trim_utf8_bom($str) {
		$bom = "\xef\xbb\xbf";
		if (strpos($str, $bom) === 0) {
			return substr($str, strlen($bom));
		}
		return $str;
	}

	/**
	 * Returns encoding options for select boxes, utf-8 and platform encoding first
	 * @return array encodings
	 */
	function get_encodings() {
		$encodings = array();
		$encodings['UTF-8'] = 'UTF-8';
		$winenc = strtoupper(get_string('localewincharset'));
		if ($winenc != '') {
			$encodings[$winenc] = $winenc;
		}
		$nixenc = strtoupper(get_string('oldcharset'));
		$encodings[$nixenc] = $nixenc;

		foreach ($this->typo3cs->synonyms as $enc) {
			$enc = strtoupper($enc);
			$encodings[$enc] = $enc;
		}
		return $encodings;
	}

	/**
	 * Returns the utf8 string corresponding to the unicode value
	 * (from php.net, courtesy - romans@void.lv)
	 *
	 * @param  int	$num one unicode value
	 * @return string the UTF-8 char corresponding to the unicode value
	 */
	function code2utf8($num) {
		if ($num < 128) {
			return chr($num);
		}
		if ($num < 2048) {
			return chr(($num >> 6) + 192) . chr(($num & 63) + 128);
		}
		if ($num < 65536) {
			return chr(($num >> 12) + 224) . chr((($num >> 6) & 63) + 128) . chr(($num & 63) + 128);
		}
		if ($num < 2097152) {
			return chr(($num >> 18) + 240) . chr((($num >> 12) & 63) + 128) . chr((($num >> 6) & 63) + 128) . chr(($num & 63) + 128);
		}
		return '';
	}

	/**
	 * Makes first letter of each word capital - words must be separated by spaces.
	 * Use with care, this function does not work properly in many locales!!!
	 * @param string $text
	 * @return string
	 */
	function strtotitle($text) {
		if (empty($text)) {
			return $text;
		}

		if (function_exists('mb_convert_case')) {
			return mb_convert_case($text, MB_CASE_TITLE,"UTF-8");
		}

		$text = $this->strtolower($text);
		$words = explode(' ', $text);
		foreach ($words as $i=>$word) {
			$length = $this->strlen($word);
			if (!$length) {
				continue;

			} else if ($length == 1) {
				$words[$i] = $this->strtoupper($word);

			} else {
				$letter = $this->substr($word, 0, 1);
				$letter = $this->strtoupper($letter);
				$rest   = $this->substr($word, 1);
				$words[$i] = $letter.$rest;
			}
		}
		return implode(' ', $words);
	}
}
?>
